Modern processors can be configured to handle execution of multiple active threads (e.g., a simultaneous multithreading (SMT) mode on a single core or multicore processor), or allow for multiple threads to execute on logical processors of one or more cores. In such instances, if one thread is running in an infinite loop of atomic memory operations such as bus locks (e.g., an atomic lock operation involving a non-writeback (WB) memory type, or when WB memory is used but an operand address crosses a cache line boundary) and another thread needs to execute a load or store operation, only the thread executing the bus locks can make any forward progress. That is, the bus locks executed by the first thread can be so close together that a new bus lock is started just after the previous bus lock finishes such that the other thread may be prevented from executing a memory operation such as a load or store operation.
Such atomic memory operations are thus very powerful and can prevent other memory operations (e.g., loads or stores) from proceeding while a bus lock is in progress. This creates a denial of service security attack where a user (e.g., executing in a user privilege level, e.g., a ring 3, or current privilege level (CPL) 3) can write a very small loop of macro-instructions that can block other users/programs from functioning. In addition to affecting operations of threads running in the same core, this type of operation/attack can even block the progress of users/programs on a different core within the same processor and/or running on a different processor package within the system.